/*
  Dart语言

  Dart是响应式编程语言，响应式编程是使用异步数据流进行编程

  变量
  var 声明的变量一旦赋值，类型便会确定，则不能再改变其类型
  dynamic 和 Object 声明的变量赋值后可以改变其类型 （这么设计有什么用）
  Object 是Dart所有对象的根基类

  常量
  const 变量是一个编译时常量，final变量在第一次使用时被初始化
  被final或者const修饰的变量，变量类型可以省略

  异步操作

  Future
  表示一个异步操作的最终完成（或失败）及其结果值的表示
  Future 的所有API的返回值仍然是一个Future对象，所以可以很方便的进行链式调用,比如：
  login().then((id){
    return getUserInfo(id);
  }).then((userInfo){
    return saveUserInfo(userInfo);
  }).then((e){
    // 处理上一个异步操作的回调
  }).catchError((e){
    //错误处理
    print(e);
  });

  还有另一种写法，最终也会转换成链式调用：
  task() async {
    try{
      String id = await login("alice","******");
      String userInfo = await getUserInfo(id);
      await saveUserInfo(userInfo);
      //执行接下来的操作
    } catch(e){
      //错误处理
      print(e);
    }
  }
  async 用来表示函数是异步的，定义的函数会返回一个Future对象，可以使用then方法添加回调函数
  await 后面是一个Future，表示等待该异步任务完成，异步完成后才会往下走；await必须出现在 async 函数内部

  Stream
  用于接收异步事件数据，和Future 不同的是，它可以接收多个异步操作的结果（成功或失败）
  Stream.fromFutures([
  // 1秒后返回结果
  Future.delayed(new Duration(seconds: 1), () {
    return "hello 1";
  }),
  // 抛出一个异常
  Future.delayed(new Duration(seconds: 2),(){
    throw AssertionError("Error");
  }),
  // 3秒后返回结果
  Future.delayed(new Duration(seconds: 3), () {
    return "hello 3";
  })
]).listen((data){
   // 多次回调
   print(data);
}, onError: (e){
   print(e.message);
},onDone: (){

});
 */

import 'dart:async';

void main() {
  const ABS_Q = '123';
  final ABS_W = 123;
  var result = 1;
  // delay();
  // wait();

  Timer.periodic(Duration(seconds: 1), (timer) {
    print('seconds=${timer.tick}');
  });
}

/*
  异步操作
  延迟两秒接收字符串
 */
void delay() {
  print('start delayed');
  Future.delayed(Duration(seconds: 2), () {
    return 'hello';
    // throw AssertionError("Error");
  }).then((value) {
    // 异步接收结果
    print('result=$value');
  }).catchError((e) {
    // 接收抛出的异常
    print(e);
  }).whenComplete(() {
    // 无论成功或者失败都会回调
    print('complete');
  });
  print('do other things...');
}

/*
  等待多个异步任务执行
 */
void wait() {
  Future.wait([
    // 2秒后返回结果
    Future.delayed(new Duration(seconds: 2), () {
      return "hello\n";
    }),
    // 4秒后返回结果
    Future.delayed(new Duration(seconds: 4), () {
      return "world\n";
    })
  ]).then((results) {
    // 所有Future都执行成功后才回调
    print(results[0] + results[1]);
  }).catchError((e) {
    // 只要有一个执行失败，就会触发错误回调
    print(e);
  }).whenComplete(() {
    // 无论成功失败都回调
    print('complete');
  });
}
